home *** CD-ROM | disk | FTP | other *** search
/ Die Ultimative Software-P…i Collection 1996 & 1997 / Die Ultimative Software-Pakete CD-ROM fur Atari Collection 1996 & 1997.iso / g / gnu_c / gempp19.zoo / gem++19 / src / gemo_m.cc < prev    next >
Encoding:
C/C++ Source or Header  |  1993-10-07  |  8.9 KB  |  475 lines
  1. /////////////////////////////////////////////////////////////////////////////
  2. //
  3. //  This file is Copyright 1992,1993 by Warwick W. Allison.
  4. //  This file is part of the gem++ library.
  5. //  You are free to copy and modify these sources, provided you acknowledge
  6. //  the origin by retaining this notice, and adhere to the conditions
  7. //  described in the file COPYING.LIB.
  8. //
  9. /////////////////////////////////////////////////////////////////////////////
  10.  
  11. //
  12. //  Include file for methods common to GEMrawobject and GEMobject.
  13. //
  14.  
  15. union bfobspec {
  16.     long packed;
  17.     struct {
  18.         unsigned short character   :  8;
  19.         signed   short framesize   :  8;
  20.         unsigned short framecol    :  4;
  21.         unsigned short textcol     :  4;
  22.         unsigned short textmode    :  1;
  23.         unsigned short fillpattern :  3;
  24.         unsigned short interiorcol :  4;
  25.     } bits;
  26. };
  27.  
  28. struct colspec {
  29.     unsigned short framecol    :  4;
  30.     unsigned short textcol     :  4;
  31.     unsigned short textmode    :  1;
  32.     unsigned short fillpattern :  3;
  33.     unsigned short interiorcol :  4;
  34. };
  35.  
  36. struct iconcolspec {
  37.     unsigned short datacol     :  4;
  38.     unsigned short maskcol     :  4;
  39.     unsigned short character   :  8;
  40. };
  41.  
  42. char* CLASS::ImageBitmap(bool Mask=FALSE) const
  43. {
  44.     switch (Type()) {
  45.      case G_IMAGE:
  46.         return ((BITBLK*)ObjectSpecific())->bi_pdata;
  47.     break;
  48.      case G_ICON:
  49.         if (Mask)
  50.             return (char*)((ICONBLK*)ObjectSpecific())->ib_pmask;
  51.         else
  52.             return (char*)((ICONBLK*)ObjectSpecific())->ib_pdata;
  53.     break;
  54.      default:
  55.         return 0;
  56.     }
  57.     return 0;
  58. }
  59.  
  60. short CLASS::ImageWidth() const
  61. {
  62.     switch (Type()) {
  63.      case G_IMAGE:
  64.         return ((BITBLK*)ObjectSpecific())->bi_wb*8;
  65.     break;
  66.      case G_ICON:
  67.         return ((ICONBLK*)ObjectSpecific())->ib_wicon;
  68.     break;
  69.      default:
  70.         return 0;
  71.     }
  72.     return 0;
  73. }
  74.  
  75. short CLASS::ImageHeight() const
  76. {
  77.     switch (Type()) {
  78.      case G_IMAGE:
  79.         return ((BITBLK*)ObjectSpecific())->bi_hl;
  80.     break;
  81.      case G_ICON:
  82.         return ((ICONBLK*)ObjectSpecific())->ib_hicon;
  83.     break;
  84.      default:
  85.         return 0;
  86.     }
  87.     return 0;
  88. }
  89.  
  90. void CLASS::SetImageBitmap(char* d, short w, short h, bool Mask=FALSE)
  91. {
  92.     switch (Type()) {
  93.      case G_IMAGE:
  94.         ((BITBLK*)ObjectSpecific())->bi_pdata=d;
  95.         ((BITBLK*)ObjectSpecific())->bi_wb=w/8;
  96.         ((BITBLK*)ObjectSpecific())->bi_hl=h;
  97.     break;
  98.      case G_ICON:
  99.         if (Mask)
  100.             ((ICONBLK*)ObjectSpecific())->ib_pmask=(short*)d;
  101.         else
  102.             ((ICONBLK*)ObjectSpecific())->ib_pdata=(short*)d;
  103.         ((ICONBLK*)ObjectSpecific())->ib_wicon=w;
  104.         ((ICONBLK*)ObjectSpecific())->ib_hicon=h;
  105.     }
  106. }
  107.  
  108. char* CLASS::Text() const
  109. {
  110.     static char boxchar_char;
  111.  
  112.     switch (Type()) {
  113.      case G_ICON:
  114.         return ((ICONBLK*)ObjectSpecific())->ib_ptext;
  115.     break;
  116.      case G_BOXTEXT:
  117.      case G_TEXT:
  118.      case G_FTEXT:
  119.      case G_FBOXTEXT:
  120.         return ((TEDINFO*)ObjectSpecific())->te_ptext;
  121.     break;
  122.      case G_BOXCHAR: // This usage is dubious.
  123.         bfobspec os;
  124.         os.packed=ObjectSpecific();
  125.         boxchar_char=os.bits.character;
  126.         return &boxchar_char;
  127.     break;
  128.      case G_STRING:
  129.      case G_BUTTON:
  130.         return (char*)ObjectSpecific();
  131.     break;
  132.      default:
  133.         return "";
  134.     }
  135. }
  136.  
  137. void CLASS::Font(int font)
  138. {
  139.     switch (Type()) {
  140.         case G_BOXTEXT:
  141.         case G_TEXT:
  142.         case G_FTEXT:
  143.         case G_FBOXTEXT:
  144.             ((TEDINFO*)ObjectSpecific())->te_font=font;
  145.     }
  146. }
  147.  
  148. int CLASS::Font() const
  149. {
  150.     switch (Type()) {
  151.      case G_BOXTEXT:
  152.      case G_TEXT:
  153.      case G_FTEXT:
  154.      case G_FBOXTEXT:
  155.         return ((TEDINFO*)ObjectSpecific())->te_font;
  156.     break;
  157.      case G_ICON:
  158.         return SMALL;
  159.     break;
  160.      default:
  161.         return IBM;
  162.     }
  163. }
  164.  
  165. int CLASS::ForeCol() const
  166. {
  167.     switch (Type()) {
  168.      case G_TEXT:
  169.      case G_BOXTEXT:
  170.      case G_FTEXT:
  171.      case G_FBOXTEXT:
  172.         return ((colspec&)(((TEDINFO*)ObjectSpecific())->te_color)).textcol;
  173.     break;
  174.      case G_IMAGE:
  175.         return ((BITBLK*)ObjectSpecific())->bi_color;
  176.     break;
  177.      case G_ICON:
  178.         return ((iconcolspec&)(((ICONBLK*)ObjectSpecific())->ib_char)).datacol;
  179.     break;
  180.      case G_BOX:
  181.      case G_IBOX:
  182.      case G_BOXCHAR:
  183.         bfobspec os;
  184.         os.packed=ObjectSpecific();
  185.         return os.bits.textcol;
  186.     break;
  187.      default:
  188.         return BLACK; // eg. G_BUTTON always black on white.
  189.     }
  190. }
  191.  
  192. int CLASS::BackCol() const
  193. {
  194.     switch (Type()) {
  195.      case G_TEXT:
  196.      case G_BOXTEXT:
  197.      case G_FTEXT:
  198.      case G_FBOXTEXT:
  199.         return ((colspec&)(((TEDINFO*)ObjectSpecific())->te_color)).interiorcol;
  200.     break;
  201.      case G_IMAGE:
  202.         return ((BITBLK*)ObjectSpecific())->bi_color;
  203.     break;
  204.      case G_ICON:
  205.         return ((iconcolspec&)(((ICONBLK*)ObjectSpecific())->ib_char)).maskcol;
  206.     break;
  207.      case G_BOX:
  208.      case G_IBOX:
  209.      case G_BOXCHAR:
  210.         bfobspec os;
  211.         os.packed=ObjectSpecific();
  212.         return os.bits.interiorcol;
  213.     break;
  214.      default:
  215.         return WHITE; // eg. G_BUTTON always black on white.
  216.     }
  217. }
  218.  
  219. int CLASS::BorderCol() const
  220. {
  221.     switch (Type()) {
  222.      case G_TEXT:
  223.      case G_BOXTEXT:
  224.      case G_FTEXT:
  225.      case G_FBOXTEXT:
  226.         return ((colspec&)(((TEDINFO*)ObjectSpecific())->te_color)).framecol;
  227.     break;
  228.      case G_BOX:
  229.      case G_IBOX:
  230.      case G_BOXCHAR:
  231.         bfobspec os;
  232.         os.packed=ObjectSpecific();
  233.         return os.bits.framecol;
  234.     break;
  235.      default:
  236.         return BLACK; // eg. G_BUTTON always has black frame
  237.     }
  238. }
  239.  
  240. int CLASS::BorderWidth() const
  241. {
  242.     switch (Type()) {
  243.      case G_TEXT:
  244.      case G_BOXTEXT:
  245.      case G_FTEXT:
  246.      case G_FBOXTEXT:
  247.         return ((TEDINFO*)ObjectSpecific())->te_thickness;
  248.     break;
  249.      case G_BOX:
  250.      case G_IBOX:
  251.      case G_BOXCHAR:
  252.         bfobspec os;
  253.         os.packed=ObjectSpecific();
  254.         return os.bits.framesize;
  255.     break;
  256.      case G_BUTTON:
  257.         if (Default()) return 3;
  258.         if (Exit()) return 2;
  259.         return 1;
  260.     break;
  261.      default:
  262.         return 0;
  263.     }
  264. }
  265.  
  266. void CLASS::ForeCol(int colourindex)
  267. {
  268.     switch (Type()) {
  269.      case G_TEXT:
  270.      case G_BOXTEXT:
  271.      case G_FTEXT:
  272.      case G_FBOXTEXT:
  273.         ((colspec&)(((TEDINFO*)ObjectSpecific())->te_color)).textcol=colourindex;
  274.     break;
  275.      case G_IMAGE:
  276.         ((BITBLK*)ObjectSpecific())->bi_color=colourindex;
  277.     break;
  278.      case G_ICON:
  279.         ((iconcolspec&)(((ICONBLK*)ObjectSpecific())->ib_char)).datacol=colourindex;
  280.     break;
  281.      case G_BOX:
  282.      case G_IBOX:
  283.      case G_BOXCHAR:
  284.         bfobspec os;
  285.         os.packed=ObjectSpecific();
  286.         os.bits.textcol=colourindex;
  287.         ObjectSpecific(os.packed);
  288.     break;
  289.      default:
  290.         ;
  291.     }
  292. }
  293.  
  294. void CLASS::BackCol(int colourindex)
  295. {
  296.     switch (Type()) {
  297.      case G_TEXT:
  298.      case G_BOXTEXT:
  299.      case G_FTEXT:
  300.      case G_FBOXTEXT:
  301.         ((colspec&)(((TEDINFO*)ObjectSpecific())->te_color)).interiorcol=colourindex;
  302.     break;
  303.      case G_IMAGE:
  304.         ((BITBLK*)ObjectSpecific())->bi_color=colourindex;
  305.     break;
  306.      case G_ICON:
  307.         ((iconcolspec&)(((ICONBLK*)ObjectSpecific())->ib_char)).maskcol=colourindex;
  308.     break;
  309.      case G_BOX:
  310.      case G_IBOX:
  311.      case G_BOXCHAR:
  312.         bfobspec os;
  313.         os.packed=ObjectSpecific();
  314.         os.bits.interiorcol=colourindex;
  315.         ObjectSpecific(os.packed);
  316.     break;
  317.      default:
  318.         ;
  319.     }
  320. }
  321.  
  322. void CLASS::BorderCol(int colourindex)
  323. {
  324.     switch (Type()) {
  325.      case G_TEXT:
  326.      case G_BOXTEXT:
  327.      case G_FTEXT:
  328.      case G_FBOXTEXT:
  329.         ((colspec&)(((TEDINFO*)ObjectSpecific())->te_color)).framecol=colourindex;
  330.     break;
  331.      case G_BOX:
  332.      case G_IBOX:
  333.      case G_BOXCHAR:
  334.         bfobspec os;
  335.         os.packed=ObjectSpecific();
  336.         os.bits.framecol=colourindex;
  337.         ObjectSpecific(os.packed);
  338.     break;
  339.      default:
  340.         ;
  341.     }
  342. }
  343.  
  344. void CLASS::BorderWidth(int width)
  345. {
  346.     switch (Type()) {
  347.      case G_TEXT:
  348.      case G_BOXTEXT:
  349.      case G_FTEXT:
  350.      case G_FBOXTEXT:
  351.         ((TEDINFO*)ObjectSpecific())->te_thickness=width;
  352.     break;
  353.      case G_BOX:
  354.      case G_IBOX:
  355.      case G_BOXCHAR:
  356.         bfobspec os;
  357.         os.packed=ObjectSpecific();
  358.         os.bits.framesize=width;
  359.         ObjectSpecific(os.packed);
  360.     break;
  361.      default:
  362.         ;
  363.     }
  364. }
  365.  
  366. void CLASS::SetText(char* t)
  367. {
  368.     switch (Type()) {
  369.      case G_ICON:
  370.         ((ICONBLK*)ObjectSpecific())->ib_ptext=t;
  371.     break;
  372.      case G_BOXTEXT:
  373.      case G_TEXT:
  374.      case G_FTEXT:
  375.      case G_FBOXTEXT:
  376.         ((TEDINFO*)ObjectSpecific())->te_ptext=t;
  377.     break;
  378.      case G_STRING:
  379.      case G_BUTTON:
  380.         ObjectSpecific((long)t);
  381.     break;
  382.      case G_BOXCHAR:
  383.         bfobspec os;
  384.         os.packed=ObjectSpecific();
  385.         os.bits.character=*t;
  386.         ObjectSpecific(os.packed);
  387.     }
  388. }
  389.  
  390. int CLASS::FillPattern() const
  391. {
  392.     switch (Type()) {
  393.      case G_BOXCHAR:
  394.      case G_BOX:
  395.      case G_IBOX:
  396.         bfobspec os;
  397.         os.packed=ObjectSpecific();
  398.         return os.bits.fillpattern;
  399.     break;
  400.      case G_BOXTEXT:
  401.      case G_TEXT:
  402.      case G_FTEXT:
  403.      case G_FBOXTEXT:
  404.         return ((colspec&)(((TEDINFO*)ObjectSpecific())->te_color)).fillpattern;
  405.     break;
  406.      default:
  407.         return 0;
  408.     }
  409. }
  410.  
  411. void CLASS::FillPattern(int f)
  412. {
  413.     switch (Type()) {
  414.      case G_BOXCHAR:
  415.      case G_BOX:
  416.      case G_IBOX:
  417.         bfobspec os;
  418.         os.packed=ObjectSpecific();
  419.         os.bits.fillpattern=f;
  420.         ObjectSpecific(os.packed);
  421.     break;
  422.      case G_BOXTEXT:
  423.      case G_TEXT:
  424.      case G_FTEXT:
  425.      case G_FBOXTEXT:
  426.         ((colspec&)(((TEDINFO*)ObjectSpecific())->te_color)).fillpattern=f;
  427.     break;
  428.      default:
  429.         ;
  430.     }
  431. }
  432.  
  433. bool CLASS::Transparent() const
  434. {
  435.     switch (Type()) {
  436.      case G_BOXCHAR:
  437.      case G_BOX:
  438.      case G_IBOX:
  439.         bfobspec os;
  440.         os.packed=ObjectSpecific();
  441.         return os.bits.textmode;
  442.     break;
  443.      case G_BOXTEXT:
  444.      case G_TEXT:
  445.      case G_FTEXT:
  446.      case G_FBOXTEXT:
  447.         return ((colspec&)(((TEDINFO*)ObjectSpecific())->te_color)).textmode;
  448.     break;
  449.      default:
  450.         return FALSE;
  451.     }
  452. }
  453.  
  454. void CLASS::Transparent(bool yes)
  455. {
  456.     switch (Type()) {
  457.      case G_BOXCHAR:
  458.      case G_BOX:
  459.      case G_IBOX:
  460.         bfobspec os;
  461.         os.packed=ObjectSpecific();
  462.         os.bits.textmode=yes;
  463.         ObjectSpecific(os.packed);
  464.     break;
  465.      case G_BOXTEXT:
  466.      case G_TEXT:
  467.      case G_FTEXT:
  468.      case G_FBOXTEXT:
  469.         ((colspec&)(((TEDINFO*)ObjectSpecific())->te_color)).textmode=yes;
  470.     break;
  471.      default:
  472.         ;
  473.     }
  474. }
  475.